home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / path.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  19.4 KB  |  706 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import generators
  5. import sys
  6. import warnings
  7. import os
  8. import fnmatch
  9. import glob
  10. import shutil
  11. import codecs
  12. import hashlib
  13. from os.path import join as pathjoin
  14. __version__ = '2.2'
  15. __all__ = [
  16.     'path']
  17. if os.name == 'nt':
  18.     
  19.     try:
  20.         import win32security
  21.     except ImportError:
  22.         win32security = None
  23.     except:
  24.         None<EXCEPTION MATCH>ImportError
  25.     
  26.  
  27. None<EXCEPTION MATCH>ImportError
  28.  
  29. try:
  30.     import pwd
  31. except ImportError:
  32.     pwd = None
  33.  
  34. _base = str
  35. _getcwd = os.getcwd
  36.  
  37. try:
  38.     if os.path.supports_unicode_filenames:
  39.         _base = unicode
  40.         _getcwd = os.getcwdu
  41.         _filesystem_encoding = sys.getfilesystemencoding()
  42. except AttributeError:
  43.     pass
  44.  
  45.  
  46. try:
  47.     (True, False)
  48. except NameError:
  49.     (True, False) = (1, 0)
  50.  
  51.  
  52. try:
  53.     basestring
  54. except NameError:
  55.     basestring = (str, unicode)
  56.  
  57. _textmode = 'r'
  58. if hasattr(file, 'newlines'):
  59.     _textmode = 'U'
  60.  
  61.  
  62. class TreeWalkWarning(Warning):
  63.     pass
  64.  
  65.  
  66. class path(_base):
  67.     
  68.     def __repr__(self):
  69.         return 'path(%s)' % _base.__repr__(self)
  70.  
  71.     
  72.     def __add__(self, more):
  73.         
  74.         try:
  75.             resultStr = _base.__add__(self, more)
  76.         except TypeError:
  77.             resultStr = NotImplemented
  78.  
  79.         if resultStr is NotImplemented:
  80.             return resultStr
  81.         
  82.         return self.__class__(resultStr)
  83.  
  84.     
  85.     def __radd__(self, other):
  86.         if isinstance(other, basestring):
  87.             return self.__class__(other.__add__(self))
  88.         else:
  89.             return NotImplemented
  90.  
  91.     
  92.     def __div__(self, rel):
  93.         return self.__class__(pathjoin(self, rel))
  94.  
  95.     __truediv__ = __div__
  96.     
  97.     def getcwd(cls):
  98.         return cls(_getcwd())
  99.  
  100.     getcwd = classmethod(getcwd)
  101.     isabs = os.path.isabs
  102.     
  103.     def url(self):
  104.         return self.__class__('file:///' + self.abspath().replace('\\', '/'))
  105.  
  106.     
  107.     def abspath(self):
  108.         return self.__class__(os.path.abspath(self))
  109.  
  110.     
  111.     def normcase(self):
  112.         return self.__class__(os.path.normcase(self))
  113.  
  114.     
  115.     def normpath(self):
  116.         return self.__class__(os.path.normpath(self))
  117.  
  118.     
  119.     def realpath(self):
  120.         return self.__class__(os.path.realpath(self))
  121.  
  122.     
  123.     def expanduser(self):
  124.         return self.__class__(os.path.expanduser(self))
  125.  
  126.     
  127.     def expandvars(self):
  128.         return self.__class__(os.path.expandvars(self))
  129.  
  130.     
  131.     def dirname(self):
  132.         return self.__class__(os.path.dirname(self))
  133.  
  134.     basename = os.path.basename
  135.     
  136.     def expand(self):
  137.         return self.expandvars().expanduser().normpath().normcase()
  138.  
  139.     
  140.     def _get_namebase(self):
  141.         (base, ext) = os.path.splitext(self.name)
  142.         return base
  143.  
  144.     
  145.     def _get_ext(self):
  146.         (f, ext) = os.path.splitext(_base(self))
  147.         return ext
  148.  
  149.     
  150.     def _get_drive(self):
  151.         (drive, r) = os.path.splitdrive(self)
  152.         return self.__class__(drive)
  153.  
  154.     parent = property(dirname, None, None, " This path's parent directory, as a new path object.\n\n        For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')\n        ")
  155.     name = property(basename, None, None, " The name of this file or directory without the full path.\n\n        For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'\n        ")
  156.     namebase = property(_get_namebase, None, None, " The same as path.name, but with one file extension stripped off.\n\n        For example, path('/home/guido/python.tar.gz').name     == 'python.tar.gz',\n        but          path('/home/guido/python.tar.gz').namebase == 'python.tar'\n        ")
  157.     ext = property(_get_ext, None, None, " The file extension, for example '.py'. ")
  158.     drive = property(_get_drive, None, None, " The drive specifier, for example 'C:'.\n        This is always empty on systems that don't use drive specifiers.\n        ")
  159.     
  160.     def splitpath(self):
  161.         (parent, child) = os.path.split(self)
  162.         return (self.__class__(parent), child)
  163.  
  164.     
  165.     def splitdrive(self):
  166.         (drive, rel) = os.path.splitdrive(self)
  167.         return (self.__class__(drive), rel)
  168.  
  169.     
  170.     def splitext(self):
  171.         (filename, ext) = os.path.splitext(self)
  172.         return (self.__class__(filename), ext)
  173.  
  174.     
  175.     def stripext(self):
  176.         return self.splitext()[0]
  177.  
  178.     if hasattr(os.path, 'splitunc'):
  179.         
  180.         def splitunc(self):
  181.             (unc, rest) = os.path.splitunc(self)
  182.             return (self.__class__(unc), rest)
  183.  
  184.         
  185.         def _get_uncshare(self):
  186.             (unc, r) = os.path.splitunc(self)
  187.             return self.__class__(unc)
  188.  
  189.         uncshare = property(_get_uncshare, None, None, ' The UNC mount point for this path.\n            This is empty for paths on local drives. ')
  190.     
  191.     
  192.     def joinpath(self, *args):
  193.         return self.__class__(pathjoin(self, *args))
  194.  
  195.     
  196.     def splitall(self):
  197.         parts = []
  198.         loc = self
  199.         while loc != os.curdir and loc != os.pardir:
  200.             prev = loc
  201.             (loc, child) = prev.splitpath()
  202.             if loc == prev:
  203.                 break
  204.             
  205.             parts.append(child)
  206.         parts.append(loc)
  207.         parts.reverse()
  208.         return parts
  209.  
  210.     
  211.     def relpath(self):
  212.         cwd = self.__class__(os.getcwd())
  213.         return cwd.relpathto(self)
  214.  
  215.     
  216.     def relpathto(self, dest):
  217.         origin = self.abspath()
  218.         dest = self.__class__(dest).abspath()
  219.         orig_list = origin.normcase().splitall()
  220.         dest_list = dest.splitall()
  221.         if orig_list[0] != os.path.normcase(dest_list[0]):
  222.             return dest
  223.         
  224.         i = 0
  225.         for start_seg, dest_seg in zip(orig_list, dest_list):
  226.             if start_seg != os.path.normcase(dest_seg):
  227.                 break
  228.             
  229.             i += 1
  230.         
  231.         segments = [
  232.             os.pardir] * (len(orig_list) - i)
  233.         segments += dest_list[i:]
  234.         if len(segments) == 0:
  235.             relpath = os.curdir
  236.         else:
  237.             relpath = pathjoin(*segments)
  238.         return self.__class__(relpath)
  239.  
  240.     
  241.     def listdir(self, pattern = None):
  242.         
  243.         try:
  244.             names = os.listdir(self)
  245.         except Exception:
  246.             return []
  247.  
  248.         if pattern is not None:
  249.             names = fnmatch.filter(names, pattern)
  250.         
  251.         return [ self / child for child in names ]
  252.  
  253.     
  254.     def dirs(self, pattern = None):
  255.         return _[1]
  256.  
  257.     
  258.     def files(self, pattern = None):
  259.         return _[1]
  260.  
  261.     
  262.     def walk(self, pattern = None, errors = 'strict'):
  263.         if errors not in ('strict', 'warn', 'ignore'):
  264.             raise ValueError('invalid errors parameter')
  265.         
  266.         
  267.         try:
  268.             childList = self.listdir()
  269.         except Exception:
  270.             if errors == 'ignore':
  271.                 return None
  272.             elif errors == 'warn':
  273.                 warnings.warn("Unable to list directory '%s': %s" % (self, sys.exc_info()[1]), TreeWalkWarning)
  274.                 return None
  275.             else:
  276.                 raise 
  277.         except:
  278.             errors == 'ignore'
  279.  
  280.         for child in childList:
  281.             if pattern is None or child.fnmatch(pattern):
  282.                 yield child
  283.             
  284.             
  285.             try:
  286.                 isdir = child.isdir()
  287.             except Exception:
  288.                 if errors == 'ignore':
  289.                     isdir = False
  290.                 elif errors == 'warn':
  291.                     warnings.warn("Unable to access '%s': %s" % (child, sys.exc_info()[1]), TreeWalkWarning)
  292.                     isdir = False
  293.                 else:
  294.                     raise 
  295.             except:
  296.                 errors == 'ignore'
  297.  
  298.             if isdir:
  299.                 for item in child.walk(pattern, errors):
  300.                     yield item
  301.                 
  302.         
  303.  
  304.     
  305.     def walkdirs(self, pattern = None, errors = 'strict', top_down = True):
  306.         if errors not in ('strict', 'warn', 'ignore'):
  307.             raise ValueError('invalid errors parameter')
  308.         
  309.         
  310.         try:
  311.             dirs = self.dirs()
  312.         except Exception:
  313.             if errors == 'ignore':
  314.                 return None
  315.             elif errors == 'warn':
  316.                 warnings.warn("Unable to list directory '%s': %s" % (self, sys.exc_info()[1]), TreeWalkWarning)
  317.                 return None
  318.             else:
  319.                 raise 
  320.         except:
  321.             errors == 'ignore'
  322.  
  323.         for child in dirs:
  324.             if top_down:
  325.                 if pattern is None or child.fnmatch(pattern):
  326.                     yield child
  327.                 
  328.             
  329.             for subsubdir in child.walkdirs(pattern, errors):
  330.                 yield subsubdir
  331.             
  332.             if not top_down:
  333.                 if pattern is None or child.fnmatch(pattern):
  334.                     yield child
  335.                 
  336.             child.fnmatch(pattern)
  337.         
  338.  
  339.     
  340.     def walkfiles(self, pattern = None, errors = 'strict'):
  341.         if errors not in ('strict', 'warn', 'ignore'):
  342.             raise ValueError('invalid errors parameter')
  343.         
  344.         
  345.         try:
  346.             childList = self.listdir()
  347.         except Exception:
  348.             if errors == 'ignore':
  349.                 return None
  350.             elif errors == 'warn':
  351.                 warnings.warn("Unable to list directory '%s': %s" % (self, sys.exc_info()[1]), TreeWalkWarning)
  352.                 return None
  353.             else:
  354.                 raise 
  355.         except:
  356.             errors == 'ignore'
  357.  
  358.         for child in childList:
  359.             
  360.             try:
  361.                 isfile = child.isfile()
  362.                 if not isfile:
  363.                     pass
  364.                 isdir = child.isdir()
  365.             except:
  366.                 if errors == 'ignore':
  367.                     continue
  368.                 elif errors == 'warn':
  369.                     warnings.warn("Unable to access '%s': %s" % (self, sys.exc_info()[1]), TreeWalkWarning)
  370.                     continue
  371.                 else:
  372.                     raise 
  373.  
  374.             if isfile:
  375.                 if pattern is None or child.fnmatch(pattern):
  376.                     yield child
  377.                 
  378.             child.fnmatch(pattern)
  379.             if isdir:
  380.                 for f in child.walkfiles(pattern, errors):
  381.                     yield f
  382.                 
  383.         
  384.  
  385.     
  386.     def fnmatch(self, pattern):
  387.         return fnmatch.fnmatch(self.name, pattern)
  388.  
  389.     
  390.     def glob(self, pattern):
  391.         cls = self.__class__
  392.         return [ cls(s) for s in glob.glob(_base(self / pattern)) ]
  393.  
  394.     
  395.     def open(self, mode = 'r'):
  396.         return file(self, mode)
  397.  
  398.     
  399.     def openfolder(self):
  400.         if os.name == 'nt' and self.exists():
  401.             Popen = Popen
  402.             import subprocess
  403.             args = [
  404.                 'explorer',
  405.                 '/select,',
  406.                 '%s' % self.abspath().encode(sys.getfilesystemencoding())]
  407.             Popen(args, shell = True)
  408.         else:
  409.             os.startfile(self.parent)
  410.  
  411.     
  412.     def bytes(self):
  413.         f = self.open('rb')
  414.         
  415.         try:
  416.             return f.read()
  417.         finally:
  418.             f.close()
  419.  
  420.  
  421.     
  422.     def write_bytes(self, bytes, append = False):
  423.         if append:
  424.             mode = 'ab'
  425.         else:
  426.             mode = 'wb'
  427.         f = self.open(mode)
  428.         
  429.         try:
  430.             f.write(bytes)
  431.         finally:
  432.             f.close()
  433.  
  434.  
  435.     
  436.     def text(self, encoding = None, errors = 'strict'):
  437.         if encoding is None:
  438.             f = self.open(_textmode)
  439.             
  440.             try:
  441.                 return f.read()
  442.             finally:
  443.                 f.close()
  444.  
  445.         else:
  446.             f = codecs.open(self, 'r', encoding, errors)
  447.             
  448.             try:
  449.                 t = f.read()
  450.             finally:
  451.                 f.close()
  452.  
  453.             return t.replace(u'\r\n', u'\n').replace(u'\r┬à', u'\n').replace(u'\r', u'\n').replace(u'┬à', u'\n').replace(u'ΓÇ¿', u'\n')
  454.  
  455.     
  456.     def write_text(self, text, encoding = None, errors = 'strict', linesep = os.linesep, append = False):
  457.         if isinstance(text, unicode):
  458.             if linesep is not None:
  459.                 text = text.replace(u'\r\n', u'\n').replace(u'\r┬à', u'\n').replace(u'\r', u'\n').replace(u'┬à', u'\n').replace(u'ΓÇ¿', u'\n')
  460.                 text = text.replace(u'\n', linesep)
  461.             
  462.             if encoding is None:
  463.                 encoding = sys.getdefaultencoding()
  464.             
  465.             bytes = text.encode(encoding, errors)
  466.         elif linesep is not None:
  467.             text = text.replace('\r\n', '\n').replace('\r', '\n')
  468.             bytes = text.replace('\n', linesep)
  469.         
  470.         self.write_bytes(bytes, append)
  471.  
  472.     
  473.     def lines(self, encoding = None, errors = 'strict', retain = True):
  474.         if encoding is None and retain:
  475.             f = self.open(_textmode)
  476.             
  477.             try:
  478.                 return f.readlines()
  479.             finally:
  480.                 f.close()
  481.  
  482.         else:
  483.             return self.text(encoding, errors).splitlines(retain)
  484.  
  485.     
  486.     def write_lines(self, lines, encoding = None, errors = 'strict', linesep = os.linesep, append = False):
  487.         if append:
  488.             mode = 'ab'
  489.         else:
  490.             mode = 'wb'
  491.         f = self.open(mode)
  492.         
  493.         try:
  494.             for line in lines:
  495.                 isUnicode = isinstance(line, unicode)
  496.                 if linesep is not None:
  497.                     if isUnicode:
  498.                         if line[-2:] in (u'\r\n', u'\r┬à'):
  499.                             line = line[:-2]
  500.                         elif line[-1:] in (u'\r', u'\n', u'┬à', u'ΓÇ¿'):
  501.                             line = line[:-1]
  502.                         
  503.                     elif line[-2:] == '\r\n':
  504.                         line = line[:-2]
  505.                     elif line[-1:] in ('\r', '\n'):
  506.                         line = line[:-1]
  507.                     
  508.                     line += linesep
  509.                 
  510.                 if isUnicode:
  511.                     if encoding is None:
  512.                         encoding = sys.getdefaultencoding()
  513.                     
  514.                     line = line.encode(encoding, errors)
  515.                 
  516.                 f.write(line)
  517.         finally:
  518.             f.close()
  519.  
  520.  
  521.     
  522.     def read_md5(self):
  523.         f = self.open('rb')
  524.         
  525.         try:
  526.             m = hashlib.md5()
  527.             while True:
  528.                 d = f.read(8192)
  529.                 if not d:
  530.                     break
  531.                 
  532.                 m.update(d)
  533.         finally:
  534.             f.close()
  535.  
  536.         return m.digest()
  537.  
  538.     exists = os.path.exists
  539.     isdir = os.path.isdir
  540.     isfile = os.path.isfile
  541.     islink = os.path.islink
  542.     ismount = os.path.ismount
  543.     if hasattr(os.path, 'samefile'):
  544.         samefile = os.path.samefile
  545.     
  546.     getatime = os.path.getatime
  547.     atime = property(getatime, None, None, ' Last access time of the file. ')
  548.     getmtime = os.path.getmtime
  549.     mtime = property(getmtime, None, None, ' Last-modified time of the file. ')
  550.     if hasattr(os.path, 'getctime'):
  551.         getctime = os.path.getctime
  552.         ctime = property(getctime, None, None, ' Creation time of the file. ')
  553.     
  554.     getsize = os.path.getsize
  555.     size = property(getsize, None, None, ' Size of the file, in bytes. ')
  556.     if hasattr(os, 'access'):
  557.         
  558.         def access(self, mode):
  559.             return os.access(self, mode)
  560.  
  561.     
  562.     
  563.     def stat(self):
  564.         return os.stat(self)
  565.  
  566.     
  567.     def lstat(self):
  568.         return os.lstat(self)
  569.  
  570.     
  571.     def get_owner(self):
  572.         if os.name == 'nt':
  573.             if win32security is None:
  574.                 raise Exception('path.owner requires win32all to be installed')
  575.             
  576.             desc = win32security.GetFileSecurity(self, win32security.OWNER_SECURITY_INFORMATION)
  577.             sid = desc.GetSecurityDescriptorOwner()
  578.             (account, domain, typecode) = win32security.LookupAccountSid(None, sid)
  579.             return domain + u'\\' + account
  580.         elif pwd is None:
  581.             raise NotImplementedError('path.owner is not implemented on this platform.')
  582.         
  583.         st = self.stat()
  584.         return pwd.getpwuid(st.st_uid).pw_name
  585.  
  586.     owner = property(get_owner, None, None, ' Name of the owner of this file or directory. ')
  587.     if hasattr(os, 'statvfs'):
  588.         
  589.         def statvfs(self):
  590.             return os.statvfs(self)
  591.  
  592.     
  593.     if hasattr(os, 'pathconf'):
  594.         
  595.         def pathconf(self, name):
  596.             return os.pathconf(self, name)
  597.  
  598.     
  599.     
  600.     def utime(self, times):
  601.         os.utime(self, times)
  602.  
  603.     
  604.     def chmod(self, mode):
  605.         os.chmod(self, mode)
  606.  
  607.     if hasattr(os, 'chown'):
  608.         
  609.         def chown(self, uid, gid):
  610.             os.chown(self, uid, gid)
  611.  
  612.     
  613.     
  614.     def rename(self, new):
  615.         os.rename(self, new)
  616.  
  617.     
  618.     def renames(self, new):
  619.         os.renames(self, new)
  620.  
  621.     
  622.     def mkdir(self, mode = 511):
  623.         os.mkdir(self, mode)
  624.  
  625.     
  626.     def makedirs(self, mode = 511):
  627.         os.makedirs(self, mode)
  628.  
  629.     
  630.     def rmdir(self):
  631.         os.rmdir(self)
  632.  
  633.     
  634.     def removedirs(self):
  635.         os.removedirs(self)
  636.  
  637.     
  638.     def touch(self):
  639.         fd = os.open(self, os.O_WRONLY | os.O_CREAT, 438)
  640.         os.close(fd)
  641.         os.utime(self, None)
  642.  
  643.     
  644.     def remove(self):
  645.         os.remove(self)
  646.  
  647.     
  648.     def unlink(self):
  649.         os.unlink(self)
  650.  
  651.     if hasattr(os, 'link'):
  652.         
  653.         def link(self, newpath):
  654.             os.link(self, newpath)
  655.  
  656.     
  657.     if hasattr(os, 'symlink'):
  658.         
  659.         def symlink(self, newlink):
  660.             os.symlink(self, newlink)
  661.  
  662.     
  663.     if hasattr(os, 'readlink'):
  664.         
  665.         def readlink(self):
  666.             return self.__class__(os.readlink(self))
  667.  
  668.         
  669.         def readlinkabs(self):
  670.             p = self.readlink()
  671.             if p.isabs():
  672.                 return p
  673.             else:
  674.                 return (self.parent / p).abspath()
  675.  
  676.     
  677.     copyfile = shutil.copyfile
  678.     copymode = shutil.copymode
  679.     copystat = shutil.copystat
  680.     copy = shutil.copy
  681.     copy2 = shutil.copy2
  682.     copytree = shutil.copytree
  683.     if hasattr(shutil, 'move'):
  684.         move = shutil.move
  685.     
  686.     rmtree = shutil.rmtree
  687.     if hasattr(os, 'chroot'):
  688.         
  689.         def chroot(self):
  690.             os.chroot(self)
  691.  
  692.     
  693.     if hasattr(os, 'startfile'):
  694.         
  695.         def startfile(self):
  696.             os.startfile(self)
  697.  
  698.     
  699.     if _base is unicode:
  700.         
  701.         def __str__(self):
  702.             return self.encode(_filesystem_encoding)
  703.  
  704.     
  705.  
  706.